package com.competition.web.admin.service.impl;

import java.sql.Time;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.stereotype.Service;

import com.admin.param.contract.IAnchorEnterpriseParam;
import com.admin.param.contract.IDesignatedMegotiatorData;
import com.admin.param.contract.IOrganizeRequestParam;
import com.admin.param.contract.IQueryEligibleEnterprisesRequestParm;
import com.admin.vo.CompanyInfoVO;
import com.admin.vo.contract.ICompanyInfoVO;
import com.basic.service.impl.BaseServiceImpl;
import com.common.util.ListConvertMap;
import com.competition.param.impl.VisitRequestParam;
import com.competition.web.admin.config.HttpRequest;
import com.competition.web.admin.mapper.VisitCustomerMapper;
import com.competition.web.admin.service.IVisitCustomerService;
import com.competition.web.admin.task.run.HandlingEligibleEnterprises;
import com.competition.web.admin.util.SpringBeanUtil;
import com.competition.web.constant.RedisConstant;
import com.competition.web.entity.GeoCodes;
import com.competition.web.entity.GeoRegeo;
import com.competition.web.entity.Poi;
import com.competition.web.entity.PoiResponse;
import com.competition.web.entity.VisitCustomer;
import com.msg.ResponseCode;
import com.page.PageResponseData;
import com.returns.value.CodeAndData;
import com.returns.value.ICodeAndData;
import com.security.admin.security.util.SpringUtil;
import com.unify.type.Data;
import com.unify.type.Department;
import com.unify.type.DepartmentFlatten;
import com.unify.type.ExploringHorsesResponse;
import com.unify.type.IExploringHorsesResponse;
import com.unify.type.SearchColumn;
import com.unify.type.SearchColumn.Option;

@Service
public class VisitCustomerServiceImpl extends BaseServiceImpl<VisitCustomer> implements IVisitCustomerService {

	private static Logger LOGGER = LoggerFactory.getLogger(VisitCustomerServiceImpl.class);

	private RedisTemplate<String, Object> redisTemplate;

	@Resource
	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	private static Map<String, Integer> STATUS = new HashMap<String, Integer>();

	static Time noon = Time.valueOf("12:00:00");

	static Map<String, String> AREA_DATA = new HashMap<String, String>();

	static Map<Integer, Integer> CONDITION_MAP = new HashMap<Integer, Integer>();

	

	/**
	 * 拜访时间字段
	 */
	static Map<Integer, String> VISIT_TIME_COLUMN = new HashMap<Integer, String>();

	private HttpRequest httpRequest;

//	ReentrantLock reentrantLock = new ReentrantLock()

	@Resource
	public void setHttpRequest(HttpRequest httpRequest) {
		this.httpRequest = httpRequest;
	}

	/**
	 * 探马 指派字段
	 */
	static Map<Integer, String> ASSIGN_COLUMN = new HashMap<Integer, String>();

	static {

		AREA_DATA.put("上海省", "上海");

		AREA_DATA.put("北京省", "北京");

		AREA_DATA.put("重庆省", "重庆");

		AREA_DATA.put("天津省", "天津");

		AREA_DATA.put("上海市", "上海");

		AREA_DATA.put("北京市", "北京");

		AREA_DATA.put("重庆市", "重庆");

		AREA_DATA.put("天津市", "天津");

		AREA_DATA.put("上海", "上海");

		AREA_DATA.put("北京", "北京");

		AREA_DATA.put("重庆", "重庆");

		AREA_DATA.put("天津", "天津");

		/**
		 * 有 131723 这个key 代表 二访 99808 --> 首访核单状态 130418 ---> 回访核单状态
		 * 
		 * 0 前道 1 后道
		 */
		CONDITION_MAP.put(131723, 1);

		CONDITION_MAP.put(99808, 0);

		CONDITION_MAP.put(130228, 1);

		ASSIGN_COLUMN.put(130228, "131591");

		ASSIGN_COLUMN.put(99808, "100490");

		ASSIGN_COLUMN.put(131723, "");

		VISIT_TIME_COLUMN.put(99808, "98173");

		VISIT_TIME_COLUMN.put(130228, "130228");

		VISIT_TIME_COLUMN.put(131723, "131723");

		// 类型（前道/后道）
		STATUS.put("前道", 0);

		STATUS.put("后道", 1);

	}

	public VisitCustomerServiceImpl(VisitCustomerMapper mapper) {
		super(mapper);
	}

	protected void insertPropteris(VisitCustomer data) {
		long time = System.currentTimeMillis() / 1000;
		data.setCreateTime(time);
		data.setUpdateTime(time);
	}

	protected void updatePropteris(VisitCustomer data) {
		data.setUpdateTime(System.currentTimeMillis() / 1000);
	}

	protected Class<VisitCustomer> getEntityClass() {
		return VisitCustomer.class;
	}

	public ICodeAndData<DepartmentFlatten[][]> getDesignatedNegotiatorAndInvitationDepartment(
			IOrganizeRequestParam organizeRequestParam, String token) {
		
		redisTemplate.delete(RedisConstant.getEligibleKey(token));
		ICodeAndData<DepartmentFlatten[][]> organize = this.getOrganize(organizeRequestParam);

		if (organize.getStatus() == ResponseCode.ERROR.getCode()) {
			return organize;
		}

		DepartmentFlatten[][] data = organize.getData();

//		// 下级部门
//		List<Department> subordinateDepartments = data.get(0).getChildren();
//		
//		// 电销部 ----  284653
//		Department electricSalesDepartment = null;
//		
//		// 加盟事业部 216651下级部门	
////		List<Department> franchiseBusinessUnit;
//		
//		// 二道  ----   398478
//		Department erdao = null;
//		
//		
//		for (Department department : subordinateDepartments) {
//			
//			if (284653 == department.getId()) {
//				// 电销部
//				
//				electricSalesDepartment = department;
//			}
//			
//			if (216651 == department.getId()) {
//				
//				erdao = department.getChildren().get(1);
//			}
//		}
//		
//		
//		List<Department> departments = new ArrayList<Department>();
//		
//		departments.add(electricSalesDepartment);
//		
//		departments.add(erdao);

		return new CodeAndData<>(data);
	}

	@Override
	public ICodeAndData<DepartmentFlatten[][]> getOrganize(IOrganizeRequestParam organizeRequestParam) {

		
		
		String key = RedisConstant.getOrganizeKey();
//
		ListOperations<String, Object> listOperations = this.redisTemplate.opsForList();

		Long size = listOperations.size(key);

		if (null == size || 0 == size) {
			return new CodeAndData<>("失败，没有人员", ResponseCode.ERROR.getCode());
		}

		DepartmentFlatten[][] departmentFlattens = new DepartmentFlatten[2][];

		int len = size.intValue();
		
		DepartmentFlatten[] flattens = new DepartmentFlatten[len];
		
		for (int i = 0; i < size; i++) {

			flattens[i] = (DepartmentFlatten) listOperations.index(key, i);
		}
		departmentFlattens[0] = flattens;
		
		
		Long sizeErdao = listOperations.size(RedisConstant.DESIGNATED_NEGOTIATOR);
		
		DepartmentFlatten[] erdaoList = new DepartmentFlatten[sizeErdao.intValue()];
		
		for (int i = 0; i < sizeErdao; i++) {
			
			erdaoList[i] = (DepartmentFlatten) listOperations.index(RedisConstant.DESIGNATED_NEGOTIATOR, i);
		}
		
		departmentFlattens[1] = erdaoList;

		return new CodeAndData<>(departmentFlattens);
//
//		List<Department> data = listOperations.range(key, 0, listOperations.size(key));
//
//		if (0 != data.size()) {
//
//			return new CodeAndData<List<Department>>(data);
//		}
//
//		ICodeAndData<List<Department>> codeAndData;
//
//		ParameterizedTypeReference<ExploringHorsesResponse<List<Department>>> parameterizedTypeReference = new ParameterizedTypeReference<ExploringHorsesResponse<List<Department>>>() {
//		};
//
//		ExploringHorsesResponse<List<Department>> exploringHorsesResponse = this.httpRequest
//				.geOrganize(organizeRequestParam, parameterizedTypeReference);
//
//		if (0 != exploringHorsesResponse.getCode()) {
//
//			codeAndData = new CodeAndData<List<Department>>(exploringHorsesResponse.getMessage(),
//					ResponseCode.ERROR.getCode());
//
//			return codeAndData;
//		}
//
//		return new CodeAndData<List<Department>>(
//				organizeForCache(exploringHorsesResponse.getData(), key, listOperations));
	}

	/**
	 * 部门列表
	 * 
	 * @return
	 */
	protected List<Department> organizeForCache(List<Department> departments, String key,
			ListOperations<String, Department> listOperation) {

		if (null == departments) {
			return new ArrayList<Department>(0);
		}

		for (Department department : departments) {
			listOperation.rightPush(key, department);
		}

		return departments;
	}
	
	@Override
	public void removeCacheResult(String token, int total) {
		
		String eligibleKey = RedisConstant.getEligibleKey(token);
		Boolean delete = redisTemplate.delete(eligibleKey);
		
		ListOperations<String, Object> opsForList = redisTemplate.opsForList();
		
		
		Long size = opsForList.size(eligibleKey);
		
		for (int i = 0; i < size; i ++ ) {
			
			if (i >= total) {
				break;
			}
			
			opsForList.rightPop(eligibleKey);
			
		}
		
		LOGGER.debug("delete: {}", delete)
		;
	}
	

	@Override
	public List<ICompanyInfoVO> getCompanyInfoVOs(String token) {

		String eligibleKey = RedisConstant.getEligibleKey(token);
		
		ListOperations<String, Object> opsForList = redisTemplate.opsForList();
		
		List<ICompanyInfoVO> companyInfoVOs = new ArrayList<ICompanyInfoVO>();
		
		Long size = opsForList.size(eligibleKey);
		
		for (int i = 0; i < size; i ++ ) {
			
			companyInfoVOs.add((ICompanyInfoVO) opsForList.rightPop(eligibleKey));
		}

		return companyInfoVOs;
	}

	public <VO extends ICompanyInfoVO, P extends IDesignatedMegotiatorData> PageResponseData<VO> companyListForSearch(
			IQueryEligibleEnterprisesRequestParm<P> enterprisesRequestParm, Class<VO> targert, String token,
			Integer time) {
		
		
		HashOperations<String, Object, VO> opsForHash = redisTemplate.opsForHash();

		Long size = opsForHash.size(RedisConstant.COMPANY_INFO);

		if (null == size) {
			return new PageResponseData<VO>();
		}
		


		String saveAnchorEnterprise = RedisConstant.getSaveAnchorEnterprise(token);

		ICompanyInfoVO anchorEnterprise = opsForHash.get(saveAnchorEnterprise, RedisConstant.SAVE_ANCHOR_ENTERPRISE);

		String companyName = anchorEnterprise.getCompanyName();
		
		List<P> abanoonedPersonForParam = enterprisesRequestParm.getDesignatedMegotiator();

		VO vo;
		
		int pageSize = 90;
		
		int pageNum = enterprisesRequestParm.getPageNum();
		
		// 当前位置
		int start = (pageNum - 1) * pageSize;
		
		long end = start + pageSize;
		
//		LOGGER.debug("start: {}, end: {}", start, end);
		
		List<VO> vos = new ArrayList<VO>();
		
		ScanOptions build = ScanOptions.scanOptions()
//				.match("*" + start + "*") // 匹配指定偏移量的键 
				/*.count(90)*/.build();
		Cursor<Entry<Object, VO>> scan = opsForHash.scan(RedisConstant.COMPANY_INFO, build);
		
		Entry<Object, VO> next;
		
		while(scan.hasNext()) {
			
			next = scan.next();
			
			vo = next.getValue();
			
			if (null == vo) {
				continue;
			}
			
//			LOGGER.debug("pos: {}", scan.getPosition());
			
			if (start >= scan.getPosition()) {
				// 偏移之前已读取的
				continue;
			}
			
//			LOGGER.debug("end: {}, size: {}", end , size);
			
			if ( end >= size) {
				break;
			}
			
//			LOGGER.debug("end: {}, pos: {}", end , scan.getPosition());
			if (end < scan.getPosition()) {
				break;
			}
			
			
			if (0 != vo.getSalesId().compareTo(enterprisesRequestParm.getInvitationId()[0])) {
				
				continue;
			}
//			LOGGER.debug("getSalesId: {}, getInvitationId: {}", vo.getSalesId() , enterprisesRequestParm.getInvitationId()[0]);

			// 过滤掉描点企业

			String cropName = vo.getCompanyName();

			if (companyName.equals(cropName)) {
				continue;
			}

			String abanoonedPerson = vo.getAbandonedPerson();

			if (isInclude(abanoonedPersonForParam, abanoonedPerson)) { // 过滤掉放弃人
				continue;
			}
			vos.add(vo);
		}
		
		scan.close();
		
		LOGGER.debug("vos: {}", vos.size());
		
		this.httpRequest.getThreadPoolTaskExecutor()
		.execute(new HandlingEligibleEnterprises<VO>(vos, (RedisTemplate) SpringUtil.getBean("redisTemplate"),
				httpRequest, enterprisesRequestParm, token, (VO) anchorEnterprise, time));

		return new PageResponseData<VO>(size, null, pageSize);

	}

//	@Override
//	public <VO extends ICompanyInfoVO, P extends IDesignatedMegotiatorData> PageResponseData<VO> companyListForSearch(
//			IQueryEligibleEnterprisesRequestParm<P> enterprisesRequestParm, Class<VO> targert, String token,
//			Integer time) {
//
//		String key = RedisConstant.getEligibleKey(token);
//
//		// 先清理掉数据
//		redisTemplate.delete(key);
//
//		VisitRequestParam visitRequestParam = new VisitRequestParam();
//		visitRequestParam.setSalesIdList(enterprisesRequestParm.getInvitationId());
//		visitRequestParam.setRole("1");
//		visitRequestParam.setPageNo(enterprisesRequestParm.getPageNum());
//
//		ParameterizedTypeReference<ExploringHorsesResponse<Data<Map<?, ?>>>> parameterizedTypeReference = new ParameterizedTypeReference<ExploringHorsesResponse<Data<Map<?, ?>>>>() {
//		};
//
//		long lTime = System.currentTimeMillis();
//
//		// 获取电邀负责的客户
//		ExploringHorsesResponse<Data<Map<?, ?>>> exploringHorsesResponse = this.httpRequest
//				.postExploringHorsesSync(visitRequestParam, parameterizedTypeReference);
//
//		LOGGER.debug("lTime: {}", System.currentTimeMillis() - lTime);
//
//		if (0 != exploringHorsesResponse.getCode()) {
//			return new PageResponseData<VO>();
//		}
//
//		Data<Map<?, ?>> data = exploringHorsesResponse.getData();
//
//		if (null == data) {
//			return new PageResponseData<VO>();
//		}
//
//		List<Map<?, ?>> list = data.getData();
//
//		// 放弃人姓名：
//		String abanoonedPerson;
//
//		List<P> abanoonedPersonForParam = enterprisesRequestParm.getDesignatedMegotiator();
//
//		VO vo;
//
//		List<Map<?, ?>> fullAddress;
//
//		int id = 0;
//
//		List<VO> vos = new ArrayList<VO>();
//
//		Map<?, ?> address;
//		String city;
//
//		Map<Long, Option> mapFromCity = getSearchColumn();
//
//		HashOperations<String, Object, ICompanyInfoVO> opsForHash = this.redisTemplate.opsForHash();
//
//		String saveAnchorEnterprise = RedisConstant.getSaveAnchorEnterprise(token);
//
//		ICompanyInfoVO anchorEnterprise = opsForHash.get(saveAnchorEnterprise, RedisConstant.SAVE_ANCHOR_ENTERPRISE);
//
//		String companyName = anchorEnterprise.getCompanyName();
//
//		for (Map<?, ?> map : list) {
//
//			// 过滤掉描点企业
//
//			String cropName = (String) map.get("corpName");
//
//			if (companyName.equals(cropName)) {
//				continue;
//			}
//
//			abanoonedPerson = (String) map.get(NAME_OF_ABANDONED_PERSON);
//
//			if (isInclude(abanoonedPersonForParam, abanoonedPerson)) { // 过滤掉放弃人
//				continue;
//			}
//
//			try {
//
//				vo = targert.newInstance();
//
//				vo.setCompanyName((String) map.get("corpName"));
//
//				vo.setCustomerId((Long) map.get("customerId"));
//
//				city = (String) map.get("99806");
//
//				if (null == city) {
//					Integer cityId = (Integer) map.get("95560");
//
//					if (null == cityId) {
//						id++;
//						continue;
//					}
//
//					city = mapFromCity.get(cityId.longValue()).getName();
//				}
//
//				vo.setCity(city);
//
//				fullAddress = (List<Map<?, ?>>) map.get("fullAddress");
//
//				if (null != fullAddress) {
//
//					address = fullAddress.get(0);
//
//					String locationAddress = address.get("locationAddress").toString();
//					String adressValue = address.get("address").toString();
//
//					if (!"".equals(locationAddress)) {
//						vo.setCompanyAddress(adressValue);
//					} else {
//						vo.setCompanyAddress(locationAddress);
//					}
//					vo.setLongitude((Double) address.get("longitude"));
//
//					vo.setLatitude((Double) address.get("latitude"));
//				}
//
//				if (null == vo.getCompanyAddress()) {
//					// 没有地址
//					String companyAddress = (String) map.get("93495");
//
//					if (null == companyAddress) {
//						LOGGER.debug("公司： {}没有地址", vo.getCompanyName());
//						id++;
//						continue;
//					}
//					vo.setCompanyAddress(companyAddress);
//				}
//
//				vo.setId((long) id);
//
//				vos.add(vo);
//
//				id++;
//
//			} catch (Exception e) {
//				e.printStackTrace();
//			}
//		}
//		this.httpRequest.getThreadPoolTaskExecutor()
//				.execute(new HandlingEligibleEnterprises<VO>(vos, (RedisTemplate) SpringUtil.getBean("redisTemplate"),
//						httpRequest, enterprisesRequestParm, token, (VO) anchorEnterprise, time));
//
//		return new PageResponseData<VO>(data.getTotalCount(), null, data.getPageSize());
//	}

	/**
	 * 判断改指定人是否在在放弃人里面
	 * 
	 * @return
	 */
	private <P extends IDesignatedMegotiatorData> boolean isInclude(List<P> designatedMegotiatorDatas,
			String abanoonedPerson) {

		if (null == designatedMegotiatorDatas || null == abanoonedPerson) {
			return false;
		}

		for (IDesignatedMegotiatorData designatedMegotiatorData : designatedMegotiatorDatas) {

			String name = designatedMegotiatorData.getName();

			if (null == name) {
				continue;
			}

			if (-1 != abanoonedPerson.indexOf(name)) {
				return true;
			}
		}

		return false;
	}

	private Map<Long, Option> getSearchColumn() {
		HashOperations<String, Object, Object> opsForHash = redisTemplate.opsForHash();

		SearchColumn searchColumn = (SearchColumn) opsForHash.get(RedisConstant.SEARCH_CITY_COLUMN,
				RedisConstant.SEARCH_HASH_CITY);

		Map<Long, Option> mapFromCity = ListConvertMap.listToMap(searchColumn.getOptions(), Option::getId);
		return mapFromCity;
	}

	/**
	 * 获取锚点企业信息
	 * 
	 * @param map
	 * @param mapFromCity
	 * @return
	 */
	private ICompanyInfoVO getCompanyInfoVO(Map<?, ?> map, Map<Long, Option> mapFromCity) {

		ICompanyInfoVO vo = new CompanyInfoVO();

		List<Map<?, ?>> fullAddress = (List<Map<?, ?>>) map.get("fullAddress");

		String city = (String) map.get("99806");

		if (null == city) {
			Integer cityId = (Integer) map.get("95560");

			if (null == cityId) {
				return null;
			}

			city = mapFromCity.get(cityId.longValue()).getName();
		}

		vo.setCity(city);

		vo.setCompanyName((String) map.get("corpName"));

		if (null != fullAddress) {

			Map<?, ?> address = fullAddress.get(0);

			String locationAddress = address.get("locationAddress").toString();
			String adressValue = address.get("address").toString();

			if (!"".equals(locationAddress)) {
				vo.setCompanyAddress(adressValue);
			} else {
				vo.setCompanyAddress(locationAddress);
			}
			vo.setLongitude((Double) address.get("longitude"));

			vo.setLatitude((Double) address.get("latitude"));
		} else {

			String companyAddress = (String) map.get("93495");

			vo.setCompanyAddress(companyAddress);

			// 请求高德定位经纬度
			PoiResponse regeo = this.httpRequest.getGaoDePoi(companyAddress, vo.getCity(), PoiResponse.class);

			setCompanyData(vo, regeo);
		}

		return vo;
	}

	private void setCompanyData(ICompanyInfoVO companyInfoVO, PoiResponse geoRegeo) {

		if (null == geoRegeo || 0 == geoRegeo.getCount()) {

			LOGGER.debug("公司地址：{}，城市：{}，公司: {}", companyInfoVO.getCompanyAddress(), companyInfoVO.getCity(),
					companyInfoVO.getCompanyName());

			companyInfoVO.setLongitude(0d);

			companyInfoVO.setLatitude(0d);

			companyInfoVO.setStatus((byte) 1);
			return;
		}

		List<Poi> geoCodes = geoRegeo.getPois();

		Poi codes = geoCodes.get(0);

		String[] location = codes.getLocation().split(",");

//		LOGGER.debug("getLocation: {}", codes.getLocation());

		companyInfoVO.setLongitude(Double.valueOf(location[0]));

		companyInfoVO.setLatitude(Double.valueOf(location[1]));
	}

	@Override
	public List<Department> getInvitationName() {
		// TODO Auto-generated method stub
//		ListOperations<String, Object> opsForList = this.redisTemplate.opsForList();
//
//		return opsForList.range(RedisConstant.INVITATION_DEPARTMENT, 0,
//				opsForList.size(RedisConstant.INVITATION_DEPARTMENT));

		return null;
	}


	@Override
	public ICodeAndData<ICompanyInfoVO> getnnchorEnterpriseCompanyInfoVO(IAnchorEnterpriseParam anchorEnterpriseParam,
			String token) {

		VisitRequestParam requestParam = new VisitRequestParam();

		requestParam.setSearchKey(anchorEnterpriseParam.getAnchorEnterprise());

		requestParam.setRole("1");

		ParameterizedTypeReference<ExploringHorsesResponse<Data<Map<?, ?>>>> parameterizedTypeReference = new ParameterizedTypeReference<ExploringHorsesResponse<Data<Map<?, ?>>>>() {
		};

		// ---------------------------------------------------
		// 获取锚点所在省市及企业经纬度
		IExploringHorsesResponse<Data<Map<?, ?>>> postExploringHorsesSync = this.httpRequest
				.postExploringHorsesSync(requestParam, parameterizedTypeReference);

		if (0 != postExploringHorsesSync.getCode()) {
			String message = postExploringHorsesSync.getMessage();
			LOGGER.error("错误消息：{}", message);
			
			return new CodeAndData<ICompanyInfoVO>(message, ResponseCode.ERROR.getCode());
		}
		
		Data<Map<?, ?>> data = postExploringHorsesSync.getData();

//		if (null == data) {
//			return new CodeAndData<ICompanyInfoVO>("找不到探马锚点企业信息, " +postExploringHorsesSync.getMessage(), ResponseCode.ERROR.getCode());
//		}

		List<Map<?, ?>> list = data.getData();

		if (null == list || 0 == list.size()) {
			return new CodeAndData<ICompanyInfoVO>("找不到探马锚点企业信息", ResponseCode.ERROR.getCode());
		}

		Map<?, ?> map = list.get(0);

		ICompanyInfoVO anchorCompanyInformation = this.getCompanyInfoVO(map, this.getSearchColumn());

		HashOperations<String, Object, ICompanyInfoVO> opsForHash = this.redisTemplate.opsForHash();

		String saveAnchorEnterprise = RedisConstant.getSaveAnchorEnterprise(token);

		opsForHash.put(saveAnchorEnterprise, RedisConstant.SAVE_ANCHOR_ENTERPRISE, anchorCompanyInformation);

		return new CodeAndData<ICompanyInfoVO>(null);

	}

	

}